Crate uncover[−][src]
Expand description
uncover
DEPRECATED: use https://github.com/matklad/cov-mark instead.
A library that makes tests easier to maintain by using instrumentation to answer these two questions:
- Which code is exercised by this test?
- Which test covers this bit of code?
Here’s a short example:
#[macro_use]
extern crate uncover;
// This defines two macros, `covers!` and `covered_by!`.
// They will be no-ops unless `cfg!(debug_assertions)` is true.
define_uncover_macros!(
enable_if(cfg!(debug_assertions))
);
fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
if 10 != s.len() {
// By using `covered_by!("unique_name")`
// we signal which test exercises this code.
covered_by!("short date");
return None;
}
if "-" != &s[4..5] || "-" != &s[7..8] {
covered_by!("wrong dashes");
return None;
}
// ...
}
#[test]
fn test_parse_date() {
{
// `covers!("unique_name")` creates a guard object
// that verifies that by the end of the scope we've
// executed the corresponding `covered_by!("unique_name")`.
covers!("short date");
assert!(parse_date("92").is_none());
}
// This will fail. Although the test looks like
// it exercises the second condition, it does not.
// The call to `covers!` call catches this bug in the test.
// {
// covers!("wrong dashes");
// assert!(parse_date("27.2.2013").is_none());
// }
{
covers!("wrong dashes");
assert!(parse_date("27.02.2013").is_none());
}
}
Notes on concurrency
Coverage is tracked via shared mutable state, so the following caveat applies:
- A
covers!
from one test might be covered by thread of another test. As a result, a test might pass when it should have failed.
The error in the opposite direction never happens: if your code covers everything with a single thread, it will do it with several threads as well.
Macros
Define covered_by!
and covers!
macros.